home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / share / cvs / contrib / pvcs2rcs < prev    next >
Encoding:
Text File  |  2005-10-16  |  37.8 KB  |  1,163 lines
  1. #! /usr/bin/perl
  2. # ---------------------------------
  3. # This program is free software; you can redistribute it and/or modify
  4. # it under the terms of the GNU General Public License as published by
  5. # the Free Software Foundation; either version 2, or (at your option)
  6. # any later version.
  7. #
  8. # This program is distributed in the hope that it will be useful,
  9. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. # GNU General Public License for more details.
  12.  
  13. ###########################################################################
  14. # FUNCTION:
  15. # To recursively walk through a PVCS archive directory tree (archives
  16. # located in VCS/ or vcs/ subdirectories) and convert them to RCS archives.
  17. # The RCS archive name is the PVCS workfile name with ",v" appended.
  18. #
  19. # SYNTAX:
  20. # pvcs_to_rcs.pl --help
  21. #
  22. # where -l indicates the operation is to be performed only in the current
  23. # directory (no recursion)
  24. # 
  25. # EXAMPLE:
  26. # pvcs_to_rcs
  27. # Would walk through every VCS or vcs subdir starting at the current directory,
  28. # and produce corresponding RCS archives one level above the VCS or vcs subdir.
  29. # (VCS/../RCS/)
  30. #
  31. # NOTES:
  32. # * This script performs little error checking and logging
  33. #   (i.e. USE AT YOUR OWN RISK)
  34. # * This script was last tested using ActiveState's port of Perl 5.005_02
  35. #   (internalcut #507) under Win95, though it does compile under Perl-5.00404
  36. #   for Solaris 2.4 run on a Solaris 2.6 system.  The script crashed
  37. #   occasionally under ActiveState's port of Perl 5.003_07 but this stopped
  38. #   happening with the update so if you are having problems, try updating Perl.
  39. #   Upgrading to cut #507 also seemed to coincide with a large speed
  40. #   improvement, so try and keep up, hey?  :)  It was executed from MKS's
  41. #   UNIX tools version 6.1 for Win32's sh.  ALWAYS redirect your output to
  42. #   a log!!!
  43. # * PVCS archives are left intact
  44. # * RCS archives are created in VCS/../RCS/ (or ./RCS using '-pflat')
  45. # * Branch labels in this script will be attached to the CVS magic
  46. #   revision number.  For branch a.b.c of a particular file, this means
  47. #   the label will be attached to revision a.b.0.c of the converted
  48. #   file.  If you use the TrunkTip (1.*) label, be aware that it will convert
  49. #   to RCS revision 0.1, which is useless to RCS and CVS.  You'll probably
  50. #   have to delete these.
  51. # * All revisions are saved with correct "metadata" (i.e. check-in date,
  52. #   author, and log message).  Any blank log message is replaced with
  53. #   "no comment".  This is because RCS does not allow non-interactive
  54. #   check in of a new revision without a comment string.
  55. # * Revision numbers are incremented by 1 during the conversion (since
  56. #   RCS does not allow revision 1.0).
  57. # * All converted branch numbers are even (the CVS paradigm)
  58. # * Version labels are assigned to the appropriate (incremented) revision
  59. #   numbers.  PVCS allows spaces and periods in version labels while RCS
  60. #   does not.  A global search and replace converts " " and "." to "_"
  61. #   There may be other cases that ought to be added.
  62. # * Any working (checked-out) copies of PVCS archives
  63. #   within the VCS/../ or vcs/../ (or possibly ./ with '-pflat')
  64. #   will be deleted (or overwritten) depending on your mode of
  65. #   operation since the current ./ is used in the checkout of each revision.
  66. #   I suppose if development continues these files could be redirected to
  67. #   temp space rather than ./ .
  68. # * Locks on PVCS archives should be removed (or the workfiles should be
  69. #   checked-in) prior to conversion, although the script will blaze through
  70. #   the archive nonetheless (But you would lose any checked out revision(s))
  71. # * The -kb option is added to the RCS archive for workfiles with the following
  72. #   extensions: .bin .out .btl .rom .a07 .lib .exe .tco .obj .t8u .c8u .o .lku
  73. #   .a and a few others.  The %bin_ext variable holds these values in regexp
  74. #   form.
  75. # * the --force-binary option can be used to convert binary files which don't
  76. #   have proper extensions, but I'd *probably* edit the %bin_ext variable.
  77. # * This script will abort occasionally with the error "invalid revision
  78. #   number".  This is known to happen when a revision comment has
  79. #   /^\s*Rev/ (Perl regexp notation) in it.  Fix the comment and start over.
  80. #   (The directory locks and existance checking make this a fairly quick
  81. #   process.)
  82. #   Binary files which do not have their mode set properly are likely to look
  83. #   corrupted on initial checkout and use, but using
  84. #   `cvs admin -kb <workfilename>' to retroactively change the RCS keyword
  85. #   substitution mode of the file to binary (and refreshing the files in any
  86. #   local workspaces they are checked out in: `rm <workfilename>; update'
  87. #   should do the trick) should end any problems with the original import.
  88. #   If anyone has checked in changes since the import, those revisions may
  89. #   be corrupted in the imported archive and therefore those changes (commits
  90. #   of corrupted data) may need to be backed out.
  91. # * This script writes lockfiles in the RCS/ directories.  It will also not
  92. #   convert an archive if it finds the RCS Archive existant in the RCS/
  93. #   directory.  This enables the conversion to quickly pick up where it left
  94. #   off after errors or interrupts occur.  If you interrupt the script make
  95. #   sure you delete the last RCS Archive File which was being written.
  96. #   If you recieve the "Invalid revision number" error, then the RCS archive
  97. #   file for that particular PVCS file will not have been created yet.
  98. # * This script will not create lockfiles when processing single
  99. #   filenames passed into the script, for hopefully obvious reasons.
  100. #   (lockfiles lock directories - DRP)
  101. # * Log the output to a file.  That makes it real easy to grep for errors
  102. #   later.  (grep for "^[ \t]*(rcs|ci):" and be aware I might have missed
  103. #   a few cases (get?  vcs?) !!!) *** Also note that this script will
  104. #   exibit some harmless RCS errors.  Namely, it will attempt to lock
  105. #   branches which haven't been created yet. ***
  106. # * I tried to keep the error and warning info up to date, but it seems
  107. #   to mean very little.  This script almost always exits with a warning
  108. #   or an error that didn't seem to cause any harm.  I didn't trace it
  109. #   and our imported source checks out and builds...
  110. #   It is probably happening when trying to convert empty directories
  111. #   or read files (possibly checked out workfiles ) which are not
  112. #   pvcs_archives.
  113. # * You must use the -pflat option when processing single filenames
  114. #   passed as arguments to the script.  This is probably a bug.
  115. # * questions, comments, additions can be sent to info-cvs@gnu.org
  116. #########################################################################
  117.  
  118.  
  119.  
  120. #
  121. # USER Configurables
  122. #
  123.  
  124. # %bin_ext should be editable from the command line.
  125. #
  126. # NOTE:  Each possible binary extension is listed as a Perl regexp
  127. #
  128. # The value associated with each regexp key is used to print a log
  129. # message when a binary file is found.
  130. my %bin_ext =
  131.     (
  132.     '\.(?i)bin$' => "Binary",
  133.     '\.(?i)out$' => "Default Compiler Output",
  134.     '\.(?i)btl$' => "",
  135.     '\.(?i)rom$' => "",
  136.     '\.(?i)a07$' => "",
  137.     '\.(?i)lib$' => "DOS/Wintel/Netware Compiler Library",
  138.     '\.(?i)lif$' => "Netware Binary File",
  139.     '\.(?i)exe$' => "DOS/Wintel Executable",
  140.     '\.(?i)tco$' => "",
  141.     '\.(?i)obj$' => "DOS/Wintel Compiler Object",
  142.     '\.(?i)res$' => "DOS/Wintel Resource File",
  143.     '\.(?i)ico$' => "DOS/Wintel Icon File",
  144.     '\.(?i)nlm$' => "Netware Loadable Module",
  145.     '\.(?i)t8u$' => "",
  146.     '\.(?i)c8u$' => "",
  147.     '\.(?i)lku$' => "",
  148.     '\.(?i)(bmp|gif|jpg|jpeg|jfif|tif|tiff|xbm|png)$' => "Image",
  149.     '\.(?i)dll$' => "DOS/Wintel Dynamically Linked Library",
  150.     '\.(?i)class$' => "Compliled Java Class File",
  151.     '\.(?i)jar$' => "Java Archive File",
  152.     '\.(?i)war$' => "Java Web Archive File",
  153.     '\.o$' => "UNIX Compiler Object",
  154.     '\.a$' => "UNIX Compiler Library",
  155.     '\.so(\.\d+\.\d+)?$' => "UNIX Shared Library"
  156.     );
  157.  
  158. # The binaries this script is dependant on:
  159. my @bin_dependancies = ("vcs", "vlog", "rcs", "ci");
  160.  
  161. # Where we should put temporary files
  162. my $tmpdir = $ENV{TMPDIR} ? $ENV{TMPDIR} : "/var/tmp";
  163.  
  164. # We use these...
  165. use strict;
  166.  
  167. use Cwd;
  168. use File::Basename;            # For the usage message.
  169. use File::Path;
  170. use IO::File;
  171. use Getopt::Long;
  172.     $Getopt::Long::bundling = 1;
  173. #    $Getopt::Long::ignorecase = 0;
  174.  
  175. my $program = basename $0;
  176. my $usage = "\
  177. usage:  $program -h
  178.         $program [-lt] [-i vcsid] [-r flat|leaf] [-p flat|leaf] [-x rcs_extension]
  179.                  [-v none|locks|exists] [options] [path...]
  180. ";
  181.  
  182. my $help = "\
  183. $usage
  184.      ----------------------------           -----------------------------------
  185.      -h | --Help                            Print this text
  186.  
  187.      General Settings
  188.      ----------------------------           -----------------------------------
  189.      --Recurse                              Recurse through directories
  190.                                             (default)
  191.      -l | --NORecurse                       Process only .
  192.      --Errorfiles                           Save a count of conversion errors
  193.                                             in the RCS archive directory
  194.                                             (default) (unimplemented)
  195.      --NOErrorfiles                         Don't save a count of conversion
  196.                                             errors (unimplemented)
  197.      ( -m | --Mode ) Convert                Convert PVCS files to RCS files
  198.                                             (default)
  199.      ( -m | --Mode ) Verify                 Perform verification ONLY (unimplemented)
  200.      ( -v | --VERIfy ) None                 Always replace existing RCS files
  201.      ( -v | --VERIfy ) LOCKS                Same as exists unless a #conv.done
  202.                                             file exists in the RCS directory.
  203.                                             In that case, only the #conv.done
  204.                                             file's existance is verified for
  205.                                             that directory.  (default)
  206.      ( -v | --VERIfy ) Exists               Don't replace existing RCS files
  207.      ( -v | --VERIfy ) LOCKDates            Verify that an existing RCS file's
  208.                                             last modification date is older
  209.                                             than that of the lockfile
  210.                                             (unimplemented)
  211.      ( -v | --VERIfy ) Revs                 Verify that the PVCS archive files
  212.                                             and RCS archive file contain the
  213.                                             same number of corresponding
  214.                                             revisions.  Add only new revisions
  215.                                             to the RCS file.  (unimplemented)
  216.      ( -v | --VERIfy ) Full                 Perform --verify=Revs and confirm
  217.                                             that the text of the revisions is
  218.                                             identical.  Add only new revisions
  219.                                             unless an error is found.  Then
  220.                                             erase the RCS archive and recreate
  221.                                             it.  (unimplemented)
  222.      -t | --Test-binaries                   Use 'which' to check \$PATH for
  223.                                             the binaries required by this
  224.                                             script (default)
  225.      --NOTest-binaries                      Don't check for binaries
  226.      --VERBose                              Enable verbose output
  227.      --NOVerbose                            Disable verbose output (default)
  228.      -w | --Warnings                        Print warning messages (default)
  229.      --NOWarnings                           Don't print warning messages
  230.  
  231.      RCS Settings
  232.      ----------------------------           -----------------------------------
  233.      ( -r | --RCS-Dirs ) leaf               RCS files stored in ./RCS (default)
  234.      ( -r | --RCS-Dirs ) flat               RCS files stored in .
  235.                                             (unimplemented)
  236.      ( -x | --RCS-Extension )               Set RCS file extension
  237.                                             (default = ',v')
  238.      --Force-binary                         Pass '-kb' to 'rcs -i' regardless of
  239.                                             the file extension
  240.      --NOForce-binary                       Only use '-kb' when the file has
  241.                                             a binary extension (default)
  242.      --Cvs-branch-labels                    Use CVS magic branch revision
  243.                                             numbers when attaching branch
  244.                                             labels (default)
  245.      --NOCvs-branch-labels                  Attach branch labels to RCS branch
  246.                                             revision numbers (unimplemented)
  247.  
  248.      PVCS Settings
  249.      ----------------------------           -----------------------------------
  250.      ( -p | --Pvcs-dirs ) leaf              PVCS files expected in ./VCS
  251.                                             (default)
  252.      ( -p | --Pvcs-dirs ) flat              PVCS files expected in .
  253.      ( -i | --VCsid ) vcsid                 Use vcsid instead of \$VCSID
  254.  
  255.      --------------------------------------------------------------------------
  256.      The optional path argument should contain the name of a file or directory
  257.      to convert.  If not given, it will default to '.'.
  258.      --------------------------------------------------------------------------
  259. ";
  260.  
  261.  
  262.  
  263. #
  264. # Initialize globals
  265. #
  266.  
  267. my ($errors, $warnings) = (0, 0);
  268. my ($curlevel, $maxlevel);
  269. my ($rcs_base_command, $ci_base_command);
  270. my ($donefile_name, $errorfile_name);
  271.  
  272. # set up the default options
  273. my %options = (
  274.     recurse => 1,
  275.     mode => "convert",
  276.     errorfiles => 1,
  277.     'rcs-dirs' => "leaf",
  278.     'rcs-extension' => ",v",
  279.     'force-binary' => 0,
  280.     'cvs-branch-labels' => 1,
  281.     'pvcs-dirs' => "leaf",
  282.     verify => "locks",
  283.     'test-binaries' => 1,
  284.     vcsid => $ENV{VCSID} || "",
  285.     verbose => 0,
  286.     debug => 0,
  287.     warnings => 1
  288.     );
  289.  
  290.  
  291.  
  292. # This is untested except under Solaris 2.4 or 2.6 and
  293. # may not be portable
  294. #
  295. # I think the readline lib or some such has an interface
  296. # which may enable this now.  The perl installer sure looks
  297. # like it's testing this kind of thing, anyhow.
  298. sub hit_any_key
  299.     {
  300.     STDOUT->autoflush;
  301.     system "stty", "-icanon", "min", "1";
  302.  
  303.     print "Hit any key to continue...";
  304.     getc;
  305.  
  306.     system "stty", "icanon", "min", "0";
  307.     STDOUT->autoflush (0);
  308.  
  309.     print "\nI always wondered where that key was...\n";
  310.     }
  311.  
  312.  
  313.  
  314. # print the usage
  315. sub print_usage
  316.     {
  317.     my $fh = shift;
  318.     unless (ref $fh)
  319.         {
  320.         my $fdn = $fh ? $fh : "STDERR";
  321.         $fh = new IO::File;
  322.         $fh->fdopen ($fdn, "w");
  323.         }
  324.  
  325.     $fh->print ($usage);
  326.     }
  327.  
  328. # print the help
  329. sub print_help
  330.     {
  331.     my $fh = shift;
  332.     unless (ref $fh)
  333.         {
  334.         my $fdn = $fh ? $fh : "STDOUT";
  335.         $fh = new IO::File;
  336.         $fh->fdopen ($fdn, "w");
  337.         }
  338.  
  339.     $fh->print ($help);
  340.     }
  341.  
  342. # print the help and exit $_[0] || 0
  343. sub exit_help
  344.     {
  345.     print_help;
  346.     exit shift || 0;
  347.     }
  348.  
  349. sub error_count
  350.     {
  351.     my $type = shift or die "$0:  error - error_count usage:  error_count type [, ref] [, LIST]\n";
  352.     my $error_count_ref;
  353.     my $outstring;
  354.  
  355.     if (ref ($_[0]) && ref ($_[0]) == "SCALAR")
  356.         {
  357.         $error_count_ref = shift;
  358.         }
  359.     else
  360.         {
  361.         $error_count_ref = \$errors;
  362.         }
  363.     $$error_count_ref++;
  364.  
  365.     push @_, "something wrong.\n" unless ( @_ > 0 );
  366.  
  367.     $outstring = sprintf "$0:  $type - " . join ("", @_);
  368.     $outstring .= sprintf " - $!\n" unless ($outstring =~ /\n$/);
  369.  
  370.     print STDERR $outstring;
  371.  
  372.     if ($options{errorfiles})
  373.         {
  374.         my $fh = new IO::File ">>$errorfile_name" or new IO::File ">$errorfile_name";
  375.         if ($fh)
  376.             {
  377.             $fh->print ($$error_count_ref . "\n");
  378.             $fh->print ($outstring);
  379.             $fh->close;
  380.             }
  381.         else
  382.             {
  383.             my $cd = cwd;
  384.             print STDERR "$0: error - failed to open errorfile $cd/$errorfile_name - $!\n"
  385.                     if ($options{debug});
  386.             }
  387.         }
  388.  
  389.     return $$error_count_ref;
  390.     }
  391.  
  392.  
  393.  
  394. # the main procedure that is run once in each directory
  395. sub execdir
  396.     {
  397.     my $dir = shift;
  398.     my ($errors, $warnings) = (0, 0);                    # We return these error counters
  399.     my $old_dir = cwd;
  400.  
  401.     local ($_, @_);
  402.  
  403.     my $i;                                    # Generic counter
  404.     my ($pvcsarchive, $workfile, $rcsarchive);                # .??v, checked out file, and ,v files,
  405.                                         # respectively
  406.     my ($rev_count, $first_vl, $last_vl, $description,
  407.             $rev_index, @rev_num, %checked_in, %author,
  408.             $relative_comment_index, @comment_string,
  409.             %comment);
  410.     my ($num_version_labels, $label_index, @label_revision, $label,
  411.             @new_label, $rcs_rev);
  412.     my ($revision, %rcs_rev_num);
  413.     my ($get_output, $rcs_output, $ci_output, $mv_output);
  414.     my ($ci_command, $rcs_command, $wtr);
  415.     my @hits;
  416.     my ($num_fields);
  417.     my $skipdirlock;                            # if true, don't write conv.out
  418.                                         # used only for single file operations
  419.                                         # at the moment
  420.     my $cd;
  421.  
  422.     my @filenames;
  423.     # We may have recieved a single file name to process...
  424.     if ( -d $dir )
  425.         {
  426.         # change into the directory to be processed
  427.         # open the current directory for listing
  428.         # initialize the list of filenames
  429.         # and set filenames equal to directory listing
  430.         unless ( ( chdir $dir ) and ( opendir CURDIR, "." ) and ( @filenames = readdir CURDIR ) )
  431.             {
  432.             $cd = cwd;
  433.             error_count 'error', \$errors, "skipping directory $dir from $cd";
  434.             chdir $old_dir or die "Failed to restore original directory ($old_dir): ", $!, ", stopped";
  435.             return ($errors, $warnings);
  436.             }
  437.  
  438.         # clean up by closing the directory
  439.         closedir(CURDIR);
  440.         }
  441.     elsif ( -f $dir ) # we recieved a single file
  442.         {
  443.         push @filenames, $dir;
  444.         $skipdirlock = 1;
  445.         }
  446.     else
  447.         {
  448.         $cd = cwd;
  449.         error_count 'error', \$errors, "no such directory/file $dir from $cd\n";
  450.         # chdir $old_dir or die "Failed to restore original directory ($old_dir): ", $!, ", stopped";
  451.         return ($errors, $warnings);
  452.         }
  453.  
  454.     # save the current directory
  455.     $cd = cwd;
  456.  
  457.     # increment the global $curlevel variable
  458.     $curlevel = $curlevel +1;
  459.  
  460.     # initialize a list for any subdirectories and any files
  461.     # we need to process
  462.     my $vcsdir = ""; 
  463.     my (@subdirs, $fn, $file, @files, @pvcsarchives);
  464.  
  465.     # print "$cd:  " . join (", ", @filenames) . "\n";
  466.     # hit_any_key;
  467.  
  468.     (@files, @pvcsarchives) = ( (), () );
  469.     # begin a for loop to execute on each filename in the list @filename
  470.     foreach $fn (@filenames)
  471.         {
  472.         # if the file is a directory...
  473.         if (-d $fn)
  474.             {
  475.             # then if we are not expecting a flat arrangement of pvcs files
  476.             # and we found a vcs directory add its files to @pvcsarchives
  477.             if (!$options{'pvcs-dirs-flat'} and $fn =~ /^vcs$/i)
  478.                 {
  479.                 if ($options{verify} =~ /^locks$/ ) {
  480.                 if ( -f $donefile_name ) {
  481.                     print "Verified existence of lockfile $cd/$donefile_name."
  482.                             . ( ($options{mode} =~ /^convert$/) ? "  Skipping directory." : "" )
  483.                             . "\n" if ($options{verbose});
  484.                     next;
  485.                 } elsif ( $options{mode} =~ /^verify$/ ) {
  486.                     print "No lockfile found for $cd .\n";
  487.                     next;
  488.                 }
  489.                 }
  490.  
  491.                 # else add the files in the vcs dir to our list of files to process
  492.                 error_count 'warning', \$warnings, "Found two vcs dirs in directory $cd.\n"
  493.                         if ($vcsdir and $options{warnings});
  494.  
  495.                 $vcsdir = $fn;
  496.  
  497.                 unless ( ( opendir VCSDIR, $vcsdir ) and ( @files = readdir VCSDIR ) )
  498.                     {
  499.                     error_count 'error', \$errors, "skipping directory &cd/$fn";
  500.                     next;
  501.                     }
  502.                 closedir VCSDIR;
  503.  
  504.                 # and so we don't need to worry about where these
  505.                 # files came from later...
  506.                 foreach $file (@files)
  507.                     {
  508.                     push @pvcsarchives, "$vcsdir/$file" if (-f "$vcsdir/$file");
  509.                     }
  510.  
  511.                 # don't want recursion here...
  512.                 @pvcsarchives = grep !/^\.\.?$/, @pvcsarchives;
  513.                 }
  514.             elsif ($fn !~ /^\.\.?$/)
  515.                 {
  516.                 next if (!$options{'rcs-dirs-flat'} and $fn =~ /^rcs$/i);
  517.                 # include it in @subdir if it's not a parent directory
  518.                 push(@subdirs,$fn);
  519.                 }
  520.             }
  521.         # else if we are processing a flat arrangement of pvcs files...
  522.         elsif ($options{'pvcs-dirs-flat'} and -f $fn)
  523.             {
  524.             if ($options{verify} =~ /^locks$/) {
  525.                 if ( -f $donefile_name) {
  526.                     print "Found lockfile $cd/$donefile_name."
  527.                         . ( ($options{mode} =~ /^convert$/) ? "  Skipping directory." : "" )
  528.                         . "\n" if ($options{verbose});
  529.                     last;
  530.                 } elsif ($options{mode} =~ /^verify$/) {
  531.                     print "No lockfile found for $cd .\n";
  532.                     last;
  533.                 }
  534.             }
  535.             # else add this to the list of files to process
  536.             push (@pvcsarchives, $fn);
  537.             }
  538.         }
  539.  
  540.     # print "pvcsarchives:  " . join (", ", @pvcsarchives) . "\n";
  541.     # print "subdirs:  " . join (", ", @subdirs) . "\n";
  542.     # hit_any_key;
  543.  
  544.     # for loop of subdirs
  545.     foreach (@subdirs)
  546.         {
  547.         # run execdir on each sub dir
  548.         if ($maxlevel >= $curlevel)
  549.             {
  550.             my ($e, $w) = execdir ($_);
  551.             $errors += $e;
  552.             $warnings += $w;
  553.             }
  554.         }
  555.  
  556.     # Print output header for each directory
  557.     print("Directory: $cd\n");
  558.  
  559.     # the @files variable should already contain the list of files
  560.     # we should attempt to process
  561.     if ( @pvcsarchives && ( $options{mode} =~ /^convert$/ ) )
  562.         {
  563.         # create an RCS directory in parent to store RCS files in
  564.         if ( !( $options{'rcs-dirs-flat'} or (-d "RCS") or mkpath ( "RCS" ) ) )
  565.             {
  566.              error_count 'error', \$errors, "failed to make directory $cd/RCS - skipping directory $cd";
  567.             @pvcsarchives = ();
  568.             # after all, we have nowhere to put them...
  569.             }
  570.         }
  571.  
  572.     # begin a for loop to execute on each filename in the list @files
  573.     foreach $pvcsarchive (@pvcsarchives)
  574.         {
  575.         my $got_workfile = 0;
  576.         my $got_version_labels = 0;
  577.         my $got_description = 0;
  578.         my $got_rev_count = 0;
  579.  
  580.         my $abs_file = $cd . "/" . $pvcsarchive;
  581.  
  582.         print("Verifying $abs_file...\n") if ($options{verbose});
  583.  
  584.         print "vlog $pvcsarchive\n";
  585.         my $vlog_output = `vlog $pvcsarchive`;
  586.  
  587.         # Split the vcs status output into individual lines
  588.         my @vlog_strings = split /\n/, $vlog_output;
  589.         my $num_vlog_strings = @vlog_strings;
  590.         $_ = $vlog_strings[0];
  591.         if ( /^\s*$/ || /^vlog: warning/ )
  592.             {
  593.             error_count 'warning', \$warnings, "$abs_file is NOT a valid PVCS archive!!!\n";
  594.             next;
  595.             }
  596.  
  597.         my $num;
  598.         # Collect all vlog output into appropriate variables
  599.         #
  600.         # This will ignore at the very least the /^\s*Archive:\s*/ field
  601.         # and maybe more.  This should not be a problem.
  602.         for ( $num = 0; $num < $num_vlog_strings; $num++ )
  603.             {
  604.             # print("$vlog_strings[$num]\n");
  605.             $_ = $vlog_strings[$num];
  606.  
  607.             if( ( /^Workfile:\s*/ ) && (!$got_workfile ) )
  608.                 {
  609.                 my $num_fields;
  610.  
  611.                 $got_workfile = 1;
  612.                 # get the string to the right of the above search (with any path stripped)
  613.                 $workfile = $';
  614.                 $num_fields = split /[\/\\]/, $workfile;
  615.                 if ( $num_fields > 1 ) 
  616.                     { 
  617.                     $workfile = $_[$num_fields - 1 ];
  618.                     }
  619.  
  620.                 $rcsarchive = $options{'rcs-dirs-flat'} ? "" : "RCS/";
  621.                 $rcsarchive .= $workfile;
  622.                 $rcsarchive .= $options{'rcs-extension'} if ($options{'rcs-extension'});
  623.                 print "Workfile is $workfile\n" if ($options{debug});
  624.                 }
  625.  
  626.             elsif ( ( /^Rev count:\s*/ ) && (!$got_rev_count ) )
  627.                 {
  628.                 $got_rev_count = 1;
  629.                 # get the string to the right of the above search
  630.                 $rev_count = $';
  631.                 print "Revision count is $rev_count\n";
  632.                 }
  633.  
  634.             elsif ( ( /^Version labels:\s*/ ) && (!$got_version_labels ) )
  635.                 {
  636.                 $got_version_labels = 1;
  637.                 $first_vl = $num+1;
  638.                 print "Version labels start at $first_vl\n" if ($options{debug});
  639.                 }
  640.  
  641.             elsif ( ( /^Description:\s*/ ) && (!$got_description ) )
  642.                 {
  643.                 $got_description = 1;
  644.                 $description = $vlog_strings[$num+1];
  645.                 print "Description is `$description'\n" if ($options{debug});
  646.                 $last_vl = $num - 1;
  647.                 }
  648.  
  649.             elsif ( /^Rev\s+/ ) # get all the revision information at once
  650.                 {
  651.                 $rev_index = 0;
  652.                 @rev_num = ();
  653.                 while ( $rev_index < $rev_count )
  654.                     {
  655.                     $_ = $vlog_strings[$num];
  656.                     /^\s*Rev\s+(\d+\.(\d+\.\d+\.)*\d+)$/;
  657.                     $rev_num[$rev_index] = $1;
  658.                     print "Found revision: $rev_num[$rev_index]\n" if ($options{debug});
  659.                     die "Not a valid revision ($rev_num[$rev_index]).\n"
  660.                         if ($rev_num[$rev_index] !~ /^(\d+\.)(\d+\.\d+\.)*\d+$/);
  661.  
  662.                     $_ = $vlog_strings[$num+1];
  663.                     /^\s*Locked\s*/ and $num++;
  664.  
  665.                     $_ = $vlog_strings[$num+1];
  666.                     /^\s*Checked in:\s*/;
  667.                     $checked_in{$rev_num[$rev_index]} = "\"" . $' . "\"";
  668.                     print "Checked in: $checked_in{$rev_num[$rev_index]}\n" if ($options{debug});
  669.  
  670.                     $_ = $vlog_strings[$num+3];
  671.                     /^\s*Author id:\s*/;
  672.                     my @fields = split;
  673.                     $author{$rev_num[$rev_index]} = "\"" . $fields[2] . "\"";
  674.                     print "Author: $author{$rev_num[$rev_index]}\n" if ($options{debug});
  675.  
  676.                     my @branches = ();
  677.                     $_ = $vlog_strings[$num+1];
  678.                     if (/^\s*Branches:\s*/)
  679.                         { 
  680.                         $num++;
  681.                         @branches = split /\s+/, $';
  682.                         }
  683.  
  684.                     $relative_comment_index = 0;
  685.                     @comment_string = ();
  686.                      while( ( ( $num + 4 + $relative_comment_index ) < @vlog_strings)
  687.                             && ( $vlog_strings[$num+4+$relative_comment_index]
  688.                                 !~ /^\s*Rev\s+(\d+\.(\d+\.\d+\.)*\d+)$/ ) )
  689.                         {
  690.                         # We need the \n added for multi-line comments.  There is no effect for
  691.                         # single-line comments since RCS inserts the \n if it doesn't exist already
  692.                         # print "Found commment line: $vlog_strings[$num+4+$relative_comment_index]\n"
  693.                         #    if ($options{debug});
  694.                         push @comment_string, $vlog_strings[$num+4+$relative_comment_index], "\n";
  695.                         $relative_comment_index += 1;
  696.                         }
  697.                     # print "Popped from comment: " . join ("", splice (@comment_string, -2)) 
  698.                     #        . "\n"
  699.                     #    if ($options{debug});
  700.                     # Pop the "-+" or "=+" line from the comment
  701.                     while ( (pop @comment_string) !~ /^-{35}|={35}$/ )
  702.                         {}
  703.                     $comment{$rev_num[$rev_index]} = join "", @comment_string;
  704.  
  705.                     $num += ( 4 + $relative_comment_index );
  706.                     print "Got comment for $rev_num[$rev_index]\n" if ($options{debug});
  707.                     print "comment string: $comment{$rev_num[$rev_index]}\n" if ($options{debug});
  708.                     $rev_index += 1;
  709.                     } # while ( $rev_index < $rev_count )
  710.                 $num -= 1; #although there should be nothing left for this to matter
  711.                 } # Get Rev information
  712.             } # for ($num = 0; $num < $num_vlog_strings; $num++)
  713.         # hit_any_key if ($options{debug});
  714.         # Create RCS revision numbers corresponding to PVCS version numbers
  715.         foreach $revision (@rev_num)
  716.             {
  717.             $rcs_rev_num{ $revision } = &pvcs_to_rcs_rev_number( $revision );
  718.             print"PVCS revision is $revision; RCS revision is $rcs_rev_num{ $revision }\n"
  719.                     if ($options{debug});
  720.             }
  721.  
  722.         # Sort the revision numbers - PVCS and RCS store them in different orders
  723.         # Clear @_ so we don't pass anything in by accident...
  724.         @_ = ();
  725.         @rev_num = sort revisions @rev_num;
  726.         print "Sorted rev_nums:\n" . join ("\n", @rev_num) . "\n" if ($options{debug});
  727.         # hit_any_key;
  728.  
  729.         # Loop through each version label, checking for need to relabel ' ' with '_'.
  730.         $num_version_labels = $last_vl - $first_vl + 1;
  731.         print "Version label count is $num_version_labels\n";
  732.         for( $i = $first_vl; $i <= $last_vl; $i += 1 )
  733.             {
  734.             # print("$vlog_strings[$i]\n");
  735.             $label_index = $i - $first_vl;
  736.             $_=$vlog_strings[$i];
  737.             print "Starting with string '$_'\n" if ($options{debug});
  738.             my @fields = split /\"/;
  739.             $label = $fields[1];
  740.             print "Got label '$label'\n" if ($options{debug});
  741.             @fields = split /\s+/, $fields[2];
  742.             $label_revision[$label_index] = $fields[2];
  743.             print "Original label is $label_revision[$label_index]\n" if ($options{debug});
  744.  
  745.             # Create RCS revision numbers corresponding to PVCS version numbers by
  746.             # adding 1 to the revision number (# after last .)
  747.             $label_revision[ $label_index ] = pvcs_to_rcs_rev_number( $label_revision [ $label_index ] );
  748.             # replace ' ' with '_', if needed
  749.             $_=$label;
  750.             $new_label[$label_index] = $label;
  751.             $new_label[$label_index] =~ s/ /_/g;
  752.             $new_label[$label_index] =~ s/\./_/g;
  753.             $new_label[$label_index] = "\"" . $new_label[$label_index] . "\"";
  754.             print"Label $new_label[$label_index] is for revision $label_revision[$label_index]\n" if ($options{debug});
  755.             }
  756.         
  757.         ##########
  758.         #
  759.         # See if the RCS archive is up to date with the PVCS archive
  760.         #
  761.         ##########
  762.         if ($options{verify} =~ /^locks|exists$/ and -f $rcsarchive)
  763.             {
  764.             print "Verified existence of $cd/$rcsarchive."
  765.                     . ( ($options{mode} =~ /^convert$/) ? "  Skipping." : "" )
  766.                     . "\n" if ($options{verbose});
  767.             next;
  768.             }
  769.  
  770.         # Create RCS archive and check in all revisions, then label.
  771.         my $first_time = 1;
  772.         foreach $revision (@rev_num)
  773.             {
  774.             # print "get -p$revision $pvcsarchive >$workfile\n";
  775.             print "get -r$revision $pvcsarchive\n";
  776.             # $vcs_output = `vcs -u -r$revision $pvcsarchive`;
  777.             # $get_output = `get -p$revision $pvcsarchive >$workfile`;
  778.             $get_output = `get -r$revision $pvcsarchive`;
  779.  
  780.             # if this is the first time, delete the rcs archive if it exists
  781.             # need for $options{verify} == none
  782.             unlink $rcsarchive if ($first_time and $options{verify} =~ /^none$/ and -f $rcsarchive);
  783.  
  784.             # Also check here whether this file ought to be "binary"
  785.             if ( $first_time )
  786.                 {
  787.                 $rcs_command = "$rcs_base_command -i";
  788.                 if ( ( @hits = grep { $workfile =~ /$_/ } keys %bin_ext ) || $options{'force-binary'} )
  789.                     {
  790.                     $rcs_command .= " -kb";
  791.                     $workfile =~ /$hits[0]/ if (@hits);
  792.                     print "Binary attribute -kb added ("
  793.                         . (@hits ? "file type is '$bin_ext{$hits[0]}' for extension '$&'" : "forced")
  794.                         . ")\n";
  795.                     }
  796.  
  797.                 $rcs_command .= " $workfile";
  798.  
  799.                 # print and execute the rcs archive initialization command
  800.                 print "$rcs_command\n";
  801.                 $wtr = new IO::File "|$rcs_command";
  802.                 $wtr->print ($description);
  803.                 $wtr->print ("\n") unless ($description =~ /\n$/s);
  804.                 $wtr->print (".\n");
  805.                 $wtr->close;
  806.  
  807.                 # $rcs_output = `$rcs_base_command -i -kb $workfile`;
  808.                 }
  809.  
  810.             # if this isn't the first time, we need to lock the rcs branch
  811.             #
  812.             # This is a little messy, but it works.  Some extra locking is attempted.
  813.             # (This happens the first time a branch is used, at the least)
  814.             my $branch = "";
  815.             my @branch;
  816.             @branch = split /\./, $rcs_rev_num{$revision};
  817.             pop @branch;
  818.             $branch = join ".", @branch;
  819.  
  820.             $rcs_output = `$rcs_base_command -l$branch $workfile` if (!$first_time);
  821.  
  822.             # If an empty comment is specified, RCS will not check in the file;
  823.             # check for this case.    (but an empty -t- description is fine - go figure!)
  824.             # Since RCS will pause and ask for a comment if one is not given,
  825.             # substitute a dummy comment "no comment".
  826.             $comment{$revision} =~ /^\s*$/ and $comment{$revision} = "no comment\n";
  827.  
  828.             $ci_command = $ci_base_command;
  829.             $ci_command .= " -f -r$rcs_rev_num{$revision} -d$checked_in{$revision}"
  830.                     . " -w$author{$revision}";
  831.  
  832.             $ci_command .= " $workfile";
  833.  
  834.             # print and execute the ci command
  835.             print "$ci_command\n";
  836.             $wtr = new IO::File "|$ci_command";
  837.             $wtr->print ($comment{$revision});
  838.             $wtr->print ("\n") unless ($comment{$revision} =~ /\n$/s);
  839.             $wtr->print (".\n");
  840.             $wtr->close;
  841.             # $ci_output = `$ci_command`;
  842.             # $ci_output = `cat $tmpdir/ci.out`;
  843.  
  844.             $first_time = 0 if ($first_time);
  845.             } # foreach revision
  846.  
  847.         # Attach version labels
  848.         for( $i = $num_version_labels - 1; $i >= 0; $i -= 1 )
  849.             {
  850.             # print "rcs -x,v -n$new_label[$i]:$label_revision[$i] $workfile\n";
  851.             $rcs_output = `$rcs_base_command -n$new_label[$i]:$label_revision[$i] $workfile`;
  852.             print "Version label $new_label[$i] added to revision $label_revision[$i]\n";
  853.             } # foreach label
  854.  
  855.         # hit_any_key;
  856.         } # foreach pvcs archive file
  857.  
  858.     # We processed a vcs directory, so if there were any files, lock it.
  859.     # We are guaranteed to have made the attempt at
  860.     #
  861.     # $skipdirlock gets set if a single file name was passed to this function to enable
  862.     # a '$0 *' operation...
  863.     if ( @pvcsarchives && !$skipdirlock)
  864.         {
  865.         my $fh = new IO::File ">>$donefile_name" or new IO::File ">$donefile_name";
  866.         if ($fh)
  867.             {
  868.             $fh->close;
  869.             }
  870.         else
  871.             {
  872.             error_count 'error', \$errors, "couldn't create lockfile $cd/$donefile_name";
  873.             }
  874.         }
  875.  
  876.     $curlevel = $curlevel - 1;
  877.  
  878.     chdir $old_dir or die "Failed to restore original directory ($old_dir): ", $!, ", stopped";
  879.     return ($errors, $warnings);
  880.     }
  881.  
  882.  
  883.  
  884. #
  885. # This function effectively does a cmp between two revision numbers
  886. # It is intended to be passed into Perl's sort routine.
  887. #
  888. # the pvcs_out is not implemented well.  It should probably be
  889. # returnning $b[0] <=> $a[0] rather than $a[0] <=> $b[0]
  890. #
  891. # The @_ argument implementation was going to be used for revision
  892. # comparison as an aid to remove the /^\sRev/ in revision comment
  893. # error.  The effort was fruitless at the time.
  894. sub revisions
  895.     {
  896.     my @a = split /\./, (defined $a) ? $a : shift;
  897.     my @b = split /\./, (defined $b) ? $b : shift;
  898.     my $function = @_ ? shift : 'rcs_in';
  899.     my ($i, $ret_val);
  900.  
  901.     die "Not enough arguments to revisions : a = ", join (".", @a),
  902.             "; b = ", join (".", @b), ", stopped"
  903.         unless (@a and @b);
  904.  
  905.     for ($i = 0; $i < scalar( @a ) && $i < scalar( @b ); $i++)
  906.         {
  907.         $a[$i] == $b[$i] or return ($a[$i] <=> $b[$i]);
  908.         }
  909.  
  910.     return 0 if (scalar (@a) == scalar (@b));
  911.  
  912.     if ($function eq 'rcs_in')
  913.         {
  914.         return (($i == @b) || -1);
  915.         }
  916.     elsif ($function eq 'pvcs_out')
  917.         {
  918.         return (($i == @a) || -1);
  919.         }
  920.     else
  921.         {
  922.         die "error - Invalid function type passed to revisions ($function)", ", stopped";
  923.         }
  924.     }
  925.  
  926.  
  927.  
  928. sub pvcs_to_rcs_rev_number
  929.     {
  930.     my($input, $num_fields, @rev_string, $return_rev_num, $i);
  931.  
  932.     $input = $_[0];
  933.     $num_fields = split /\./, $input;
  934.     @rev_string = @_;
  935.     # @rev_string[$num_fields-1] += 1;
  936.  
  937.     for( $i = 1; $i < $num_fields; $i += 1 )
  938.         {
  939.         if ( $i % 2 )
  940.             {
  941.             # DRP: 10/1
  942.             # RCS does not allow revision zero
  943.             $rev_string[ $i ] += 1;
  944.             }
  945.         elsif ( $i )
  946.             {
  947.             # DRP: 10/1
  948.             # Branches must have even references for compatibility
  949.             # with CVS's magic branch numbers.
  950.             # (Indexes 2, 4, 6...)
  951.             $rev_string[ $i ] *= 2;
  952.             }
  953.         }
  954.  
  955.     # If this is a branch revision # (PVCS: a.b.c.*) then we want the CVS
  956.     # revision # instead.  It's okay to do this conversion here since we
  957.     # never commit to branches.  We'll only get a PVCS revision # in that
  958.     # form when looking through the revision labels.
  959.     if ($input =~ /\*$/)
  960.         {
  961.         pop @rev_string;
  962.         push @rev_string, splice (@rev_string, -1, 1, "0");
  963.         }
  964.  
  965.     $return_rev_num = join ".", @rev_string;
  966.     return $return_rev_num;
  967.     }
  968.  
  969.  
  970.  
  971.  
  972.  
  973. ###
  974. ###
  975. ###
  976. ###
  977. ###
  978. ###   MAIN program: checks to see if there are command line parameters
  979. ###
  980. ###
  981. ###
  982. ###
  983. ###
  984.  
  985.  
  986.  
  987.  
  988.     
  989. # and read the options
  990. die $usage unless GetOptions (\%options, "h|help" => \&exit_help, 
  991.         "recurse!", "mode|m=s", "errorfiles!", "l", "rcs-dirs|rcs-directories|r=s",
  992.         "pvcs-dirs|pvcs-directories|p=s", "test-binaries|t!",
  993.         "rcs-extension=s", "verify|v=s", "vcsid|i=s", "verbose!", "debug!",
  994.         "force-binary!", "cvs-branch-labels!", "warnings|w!");
  995.  
  996.  
  997.  
  998. #
  999. # Special processing for -l !^#%$^@#$%#$
  1000. #
  1001. # At the moment, -l overrides --recurse, regardless of the order the
  1002. # options were passed in
  1003. #
  1004. $options{recurse} = 0 if defined $options{l};
  1005. delete $options{l};
  1006.  
  1007.  
  1008.  
  1009. # Make sure we got acceptable values for rcs-dirs and pvcs-dirs
  1010. my @hits = grep /^$options{'rcs-dirs'}/i, ("leaf", "flat");
  1011. @hits == 1 or die
  1012.           "$0: $options{'rcs-dirs'} invalid argument to --rcs-dirs or ambiguous\n"
  1013.         . "    abbreviation.\n"
  1014.         . "    Must be one of: 'leaf' or 'flat'.\n"
  1015.         . $usage;
  1016. $options{'rcs-dirs'} = $hits[0];
  1017. $options{'rcs-dirs-flat'} = ($options{'rcs-dirs'} =~ /flat/);
  1018. delete $options{'rcs-dirs'};
  1019.  
  1020. @hits = grep /^$options{'pvcs-dirs'}/i, ("leaf", "flat");
  1021. @hits == 1 or die
  1022.           "$0: $options{'pvcs-dirs'} invalid argument to --pvcs-dirs or ambiguous\n"
  1023.         . "    abbreviation.\n"
  1024.         . "    Must be one of: 'leaf' or 'flat'.\n"
  1025.         . $usage;
  1026. $options{'pvcs-dirs'} = $hits[0];
  1027. $options{'pvcs-dirs-flat'} = ($options{'pvcs-dirs'} =~ /flat/);
  1028. delete $options{'pvcs-dirs'};
  1029.  
  1030. # and for verify
  1031. @hits = grep /^$options{verify}/i, ("none", "locks", "exists", "lockdates", "revs", "full");
  1032. @hits == 1 or die
  1033.           "$0: $options{verify} invalid argument to --verify or ambiguous\n"
  1034.         . "    abbreviation.\n"
  1035.         . "    Must be one of: 'none', 'locks', 'exists', 'lockdates', 'revs',\n"
  1036.         . "    or 'full'.\n"
  1037.         . $usage;
  1038. $options{verify} = $hits[0];
  1039. $options{verify} =~ /^none|locks|exists$/ or die
  1040.           "$0: --verify=$options{verify} unimplemented.\n"
  1041.         . $usage;
  1042.  
  1043. # and mode
  1044. @hits = grep /^$options{mode}/i, ("convert", "verify");
  1045. @hits == 1 or die
  1046.           "$0: $options{mode} invalid argument to --mode or ambiguous abbreviation.\n"
  1047.         . "    Must be 'convert' or 'verify'.\n"
  1048.         . $usage;
  1049. $options{mode} = $hits[0];
  1050.  
  1051. $options{'cvs-branch-labels'} or die
  1052.           "$0: RCS Branch Labels unimplemented.\n"
  1053.         . $usage;
  1054.  
  1055. # export VCSID into th environment for ourselves and our children
  1056. $ENV{VCSID} = $options{vcsid};
  1057.  
  1058.  
  1059.  
  1060. #
  1061. # Verify we have all the binary executables we need to run this script
  1062. #
  1063. # Allowed this feature to be disabled in case which is missing or we are
  1064. # running on a system which does not return error codes properly (e.g. WIN95)
  1065. #
  1066. #      -- i.e. I don't feel like grepping output yet. --
  1067. #
  1068. my @missing_binaries = ();
  1069. if ($options{'test-binaries'})
  1070.     {
  1071.     foreach (@bin_dependancies)
  1072.         {
  1073.         my $output = qx/which $_ 2>&1/;
  1074.         print $output if $options{verbose} && $output;
  1075.         if ($? || $output =~ /^no/)
  1076.             {
  1077.             push @missing_binaries, $_;
  1078.             }
  1079.         }
  1080.  
  1081.     if (scalar @missing_binaries)
  1082.         {
  1083.         print STDERR "The following executables were not found in your PATH: "
  1084.             . join ( " ", @missing_binaries )
  1085.             . "\n"
  1086.             . "You must correct this before continuing.\n";
  1087.         exit 1;
  1088.         }
  1089.     }
  1090. delete $options{'test-binaries'};
  1091.  
  1092.  
  1093.  
  1094. #
  1095. # set up our base archive manipulation commands
  1096. #
  1097.  
  1098. # set up our rcs_command mods
  1099. $rcs_base_command = "rcs";
  1100. $rcs_base_command .= " -x$options{'rcs-extension'}" if ($options{'rcs-extension'});
  1101.  
  1102. # set up our rcs_command mods
  1103. $ci_base_command = "ci";
  1104. $ci_base_command .= " -x$options{'rcs-extension'}" if ($options{'rcs-extension'});
  1105.  
  1106.  
  1107.  
  1108. #
  1109. # So our logs fill in a manner we can monitor with 'tail -f' fairly easily:
  1110. #
  1111. STDERR->autoflush (1);
  1112. STDOUT->autoflush (1);
  1113.  
  1114.  
  1115.  
  1116. # Initialize the globals we use to keep track of recursion
  1117. if ($options{recurse})
  1118.     {
  1119.     $maxlevel = 10000;        # Arbitrary recursion limit
  1120.     }
  1121. else
  1122.     {
  1123.     $maxlevel = 1;
  1124.     }
  1125. delete $options{recurse};
  1126.  
  1127. # So we can lock the directories behind us
  1128. $donefile_name = $options{'rcs-dirs-flat'} ? "" : "RCS/";
  1129. $errorfile_name = $donefile_name . "#conv.errors";
  1130. $donefile_name .= "#conv.done";
  1131.  
  1132.  
  1133.  
  1134. #
  1135. # start the whole thing and drop the return code on exit
  1136. #
  1137. push (@ARGV, ".") unless (@ARGV);
  1138. while ($_ = shift)
  1139.     {
  1140.     # reset the recursion level (corresponds to directory depth)
  1141.     # level 0 is the first directory we enter...
  1142.     $curlevel = -1;
  1143.     my ($e, $w) = execdir($_);
  1144.     $errors += $e;
  1145.     $warnings += $w;
  1146.     }
  1147.  
  1148.  
  1149.  
  1150. print STDERR "$0:  " . ($errors ? "Aborted" : "Done") . ".\n";
  1151. print STDERR "$0:  ";
  1152. print STDERR ($errors ? $errors : "No") . " error" . (($errors != 1) ? "s" : "");
  1153. print STDERR ", " . ($warnings ? $warnings : "no") . " warning" . (($warnings != 1) ? "s" : "")
  1154.         if ($options{warnings});
  1155. print STDERR ".\n";
  1156.  
  1157.  
  1158.  
  1159. #
  1160. # Woo-hoo!  We made it!
  1161. #
  1162. exit $errors;
  1163.